/*
* 
* Fichier source projet pac-man.
* 
* Cree le : vendredi 18 novembre 2011 à 13 : 18.
* Auteurs : Gregoire BARRET.
* 
* Nom de fichier : main.c
* Chemin du fichier : client/main.c
* 
* Description :
* 
*/

 
#include <stdio.h>
#include <unistd.h>
//#include <stdlib.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <strings.h>
#include <errno.h>
#include <netdb.h>
#include <ncurses.h>

//#define SERVEURNAME "0.0.0.0"

static pthread_mutex_t verrou;

struct Struct_carte
{
	char carte[25][25];
	int joueur1nbpoint;
	int joueur2nbpoint;
	int nbviejoueur1;
	int nbviejoueur2;
	char char_envoi;
	int continuer;
	char* addresse;
	int port;
};

int affiche_map ( struct Struct_carte* carte);
int deplacement(struct Struct_carte* carte);
void* ecoute_sockette(void *data);

int main(int argc, char *argv[])
{
	int bla;
	pthread_t thread_ecoute;

	/* vaarriables relatives a l'affichage*/
	int row,col;
	struct Struct_carte carte;
	int i,j;
	carte.continuer=1;

	carte.addresse = argv[1];
	carte.port = atoi(argv[2]);

	/* initialisation de ncuses*/
	initscr(); //start ncurses mode
	raw();
//	getmaxyx(stdscr,row,col);
	keypad(stdscr,TRUE);
	noecho();
	nodelay(stdscr, TRUE);
	clear();

	

	pthread_create(&thread_ecoute, NULL, ecoute_sockette, &carte);

	
	usleep(1000);//on attend l'initialisation du thread
	printw("appuier sur une touche pour continuer\n");
	refresh(); 
	while ( (getch()) == ERR){}

	if (carte.continuer == 0){}
	else{

	/*debut du programme d'affichage*/	
	affiche_map( &carte);
	do{
		clear();
		pthread_mutex_lock(&verrou);
		affiche_map(&carte);
		deplacement(&carte);
		pthread_mutex_unlock(&verrou);
		refresh(); 
		usleep(100000);


	}while (carte.continuer == 1);

	}




	endwin(); //end ncurses mode
	/*supression de la sockette d'ecoute*/
/*
	while(1){
		carte.char_envoi = 'H';
		printf("%c\n", carte.char_envoi);
		printf("%c\n", carte.carte);
		usleep(1000000);
	}
*/
	pthread_join(thread_ecoute , NULL);


	return 0;
}

int deplacement( struct Struct_carte* carte)
{
	int ch;

	/*on regarde si on appuie sur une touche, et la quel*/
	if ( (ch = getch()) != ERR)
	{
	switch(ch)
	{
		case KEY_LEFT:
			carte->char_envoi = 'G';
			break;
		case KEY_RIGHT:
			carte->char_envoi = 'D';
			break;
		case KEY_UP:
			carte->char_envoi = 'H';
			break;
		case KEY_DOWN:
			carte->char_envoi = 'B';
			break;
		case 27:
			carte->continuer = 0;
			break;
	}
	}

	return 0;


}

int affiche_map ( struct Struct_carte* carte)
{
	int i,j;
	/* on affiche la carte*/
	for (i=0;i<25;i++)
	{
		for (j=0;j<25;j++){
			printw("%c",carte->carte[i][j]);
		}
		printw("\n");
	}

	/*on affiche la derniere ligne*/
	printw("joueur 1:%d  ", carte->joueur1nbpoint);
	printw("vie :%d ", carte->nbviejoueur1);
	printw("joueur 2:%d  ", carte->joueur2nbpoint);
	printw("vie:%d", carte->nbviejoueur2);
	printw("\n");



}

void* ecoute_sockette(void* data)
{
	/*variables relatives au reseau*/
	int sockcomm = socket(AF_INET, SOCK_STREAM,0);
	struct sockaddr_in servaddr;
	struct hostent *serverHostent;
	long hostAddr;
	long status;
	int addrlength = sizeof(struct sockaddr_in);
	char buffer[26][25];



	/*autres varriables*/
	int i,j;
	char const *pointeur = NULL;
	char buffer26[25];//contient la derniere ligne du buffer

	 struct Struct_carte *carte = (  struct Struct_carte *) data;
	char *serveur_name = carte->addresse ;


/* initialisation du serveur de connection*/
	bzero(&servaddr,sizeof(servaddr));
	hostAddr = inet_addr(carte->addresse);
	if ( (long)hostAddr != (long)-1)
		  bcopy(&hostAddr,&servaddr.sin_addr,sizeof(hostAddr));
	else
	{
		  serverHostent = gethostbyname(carte->addresse);
		  if (serverHostent == NULL)
		  {
		    printw("ca chie gethost\n");
		    carte->continuer = 0;
		  }
		  bcopy(serverHostent->h_addr,&servaddr.sin_addr,serverHostent->h_length);
	}

	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(carte->port);

	printw("thread connection: demande d'une connection\n");
	refresh();
	if(connect(sockcomm , (struct sockaddr *)& servaddr,sizeof(servaddr))!= 0)
	{
		printw("thread connection: delais ecouler \n");
		refresh();
		carte->continuer = 0;

	}
	else
	{
		printw("thread connection: connecter\n");
		refresh();


		do{
			recv(sockcomm, buffer, sizeof(buffer), 0);

			/* on ecrit le contenu du buffer dans la structure de carte*/
			pthread_mutex_lock(&verrou);
			for (i=0;i<25;i++)
			{
				for (j=0;j<25;j++){
					carte->carte[i][j] = buffer[i][j];
				}
			}
		
			for (i=0;i<25;i++){
				buffer26[i] = buffer[25][i];
			}
		
			pointeur = strtok(buffer26 , " ");
			carte->joueur1nbpoint = atoi(pointeur);
			pointeur = strtok(NULL , " ");
			carte->nbviejoueur1 = atoi(pointeur);
			pointeur = strtok(NULL , " ");
			carte->joueur2nbpoint = atoi(pointeur);
			pointeur = strtok(NULL , " ");
			carte->nbviejoueur2 = atoi(pointeur);


			send(sockcomm,&carte->char_envoi,sizeof(carte->char_envoi),0);
			pthread_mutex_unlock(&verrou);

			usleep(500000);

		}while ( carte->continuer == 1 );
	}

	close(sockcomm);//fermeture de la sockette


}
